﻿#include "include_commobj_header.h"
#include "util/fne.h"
#include "bstring/bstrwrap.h"
#include "util/vector.hpp"

// 本命令被隐藏, 原始名字 = "构造函数", 本命令为构造函数
// 调用格式: _SDT_NULL (快速文本对象).构造函数, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_Constructor_20_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	self = new CBString{};
}

// 本命令被隐藏, 原始名字 = "复制构造函数", 本命令为复制构造函数
// 调用格式: _SDT_NULL (快速文本对象).复制构造函数, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_CopyConstructor_21_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	const auto& rht = fne::args_to_other<CBString>(pArgInf);
	self = new CBString{*rht};
}

// 本命令被隐藏, 原始名字 = "析构函数", 本命令为析构函数
// 调用格式: _SDT_NULL (快速文本对象).析构函数, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_Destructor_22_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	if (self)
	{
		self->CBString::~CBString();
		operator delete(self);
	}
	self = nullptr;
}

// 调用格式: SDT_INT (快速文本对象).取长度, 命令说明: "返回本对象文本中的字符个数（每个汉字视为两个字符）。"
// 无参数
COMMOBJ_EXTERN_C void commobj_GetLength_23_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	pRetData->m_int = self->length();
}

// 调用格式: SDT_TEXT (快速文本对象).取文本, 命令说明: "取本对象中的全部或部分文本。"
// 参数<1>: [起始位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字符，2表示第二个字符，依次类推；位置索引也可以为负值，-1表示最后一个字符，-2表示倒数第二个字符，依次类推。如果本参数被省略，默认为1。"
// 参数<2>: [字符数 SDT_INT], 参数说明: "如果本参数被省略，默认为从“起始位置”到文本结尾的字符个数。"
COMMOBJ_EXTERN_C void commobj_GetText_24_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;
	const INT arg2 = pArgInf[2].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (!pArgInf[1].empty())
	{
		if (arg1 < 0)
			start = self->length() + arg1;
		if (arg1 > 0)
			start = arg1 - 1;
	}

	if(start >= self->length())
	{
		pRetData->m_pText = fne::clone_text(reinterpret_cast<char*>(self->data), 0);
		return;
	}

	auto len = self->length() - start;

	if (!pArgInf[2].empty() && arg2 >= 0)
	{
		len = min(len, arg2);
	}

	pRetData->m_pText = fne::clone_text(reinterpret_cast<char*>(self->data) + start, len);
}

// 调用格式: SDT_BOOL (快速文本对象).置文本, 命令说明: "将参数数据转换为文本并设置为本对象文本。"
// 参数<1>: 数据 数组/非数组 _SDT_ALL, 参数说明: "参数类型支持各种基本数据类型及其数组数据。"
COMMOBJ_EXTERN_C void commobj_SetText_25_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	//void*    arg1 = pArgInf[1].m_pAryData;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	self->trunc(0);
	for (int i = 0; i < nArgCount; ++i)
	{
		fne::append_to_string(&pArgInf[i + 1], *self);
	}
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).清除文本, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_EmptyText_26_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	self->trunc(0);
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).添加, 命令说明: "将参数转换成文本并添加到本对象文本的末尾。"
// 参数<1>: 欲添加的数据 数组/非数组 _SDT_ALL, 参数说明: "参数类型支持各种基本数据类型及其数组数据。"
COMMOBJ_EXTERN_C void commobj_Append_27_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	//void* arg1 = pArgInf[1].m_pAryData;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	for (int i = 0; i < nArgCount; ++i)
	{
		fne::append_to_string(&pArgInf[i + 1], *self);
	}
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).插入, 命令说明: "将参数数据转换为文本后插入本对象文本中的指定位置之前。"
// 参数<1>: [插入位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字符，2表示第二个字符，依次类推；位置索引也可以为负值，-1表示最后一个字符，-2表示倒数第二个字符，依次类推。如果本参数被省略，默认为1。"
// 参数<2>: 欲插入的数据 数组/非数组 _SDT_ALL, 参数说明: "参数类型支持各种基本数据类型及其数组数据。"
COMMOBJ_EXTERN_C void commobj_Insert_28_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;
	//void* arg2 = pArgInf[2].m_pAryData;

	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (!pArgInf[1].empty())
	{
		if (arg1 < 0)
			start = self->length() + arg1;
		if (arg1 > 0)
			start = arg1 - 1;
	}
	CBString insert_text{};
	for (int i = 0; i < nArgCount - 1; ++i)
	{
		fne::append_to_string(&pArgInf[i + 2], insert_text);
	}
	self->insert(start, insert_text);
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).删除字符, 命令说明: "删除文本中从指定字符开始的指定个数的字符（包括起始删除位置处的字符）"
// 参数<1>: 起始删除位置 SDT_INT, 参数说明: "位置索引可以为正值，1表示第一个字符，2表示第二个字符，依次类推；位置索引也可以为负值，-1表示最后一个字符，-2表示倒数第二个字符，依次类推。"
// 参数<2>: 欲删除的字符数 SDT_INT, 参数说明: "如果参数值为-1，表示删除从“起始删除位置”开始到文本结尾的所有字符。"
COMMOBJ_EXTERN_C void commobj_DeleteChars_29_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;
	const INT arg2 = pArgInf[2].m_int;

	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (arg1 < 0)
		start = self->length() + arg1;
	if (arg1 > 0)
		start = arg1 - 1;
	auto len = arg2;
	if (arg2 < 0)
		len = self->length() - start;
	self->remove(start, len);
	pRetData->m_bool = TRUE;
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_30, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_Contains_30_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	pRetData->m_bool = self->find(arg1) != BSTR_ERR;
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_31, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_StartWith_31_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	const auto len = static_cast<int>(strlen(arg1));
	if (len > self->length())
	{
		pRetData->m_bool = FALSE;
		return;
	}
	pRetData->m_bool = memcmp(self->data, arg1, len) == 0;
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_32, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_EndWith_32_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	const auto len = static_cast<int>(strlen(arg1));
	if (len > self->length())
	{
		pRetData->m_bool = FALSE;
		return;
	}

	pRetData->m_bool = memcmp(self->data + self->length() - len, arg1, len) == 0;
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_33, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj_FindLong_33_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	const INT arg2 = pArgInf[2].m_int;
	const BOOL arg3 = pArgInf[3].m_bool;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (!pArgInf[2].empty())
	{
		if (arg2 < 0)
			start = self->length() + arg2;
		if (arg2 > 0)
			start = arg2 - 1;
	}
	int res;
	if (arg3)
		res = self->boyer_moore_find(arg1, start);
	else
		res = self->boyer_moore_caselessfind(arg1, start);
	pRetData->m_int = res < 0 ? res : res + 1;
}

// 调用格式: SDT_INT (快速文本对象).寻找文本, 命令说明: "寻找指定文本在本对象文本中从“起始寻找位置”开始第一次出现时的位置索引（>0），未找到则返回-1。"
// 参数<1>: 欲寻找的文本 SDT_TEXT, 参数说明: NULL
// 参数<2>: [起始寻找位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字符，2表示第二个字符，依次类推；位置索引也可以为负值，-1表示最后一个字符，-2表示倒数第二个字符，依次类推。如果本参数被省略，默认为1。"
// 参数<3>: 是否区分大小写 SDT_BOOL, 参数说明: NULL
COMMOBJ_EXTERN_C void commobj_Find_34_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	const INT arg2 = pArgInf[2].m_int;
	const BOOL arg3 = pArgInf[3].m_bool;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (!pArgInf[2].empty())
	{
		if (arg2 < 0)
			start = self->length() + arg2;
		if (arg2 > 0)
			start = arg2 - 1;
	}
	int res;
	if (arg3)
		res = self->find(arg1, start);
	else
		res = self->caselessfind(arg1, start);
	pRetData->m_int = res < 0 ? res : res + 1;
}

// 调用格式: SDT_INT (快速文本对象).倒找文本, 命令说明: "在本对象文本中从“起始寻找位置”开始向文本开头方向寻找指定文本第一次出现时的位置索引（相对于文本头），未找到则返回-1。"
// 参数<1>: 欲寻找的文本 SDT_TEXT, 参数说明: NULL
// 参数<2>: [起始寻找位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字符，2表示第二个字符，依次类推；位置索引也可以为负值，-1表示最后一个字符，-2表示倒数第二个字符，依次类推。如果本参数被省略，默认为1。"
// 参数<3>: 是否区分大小写 SDT_BOOL, 参数说明: NULL
COMMOBJ_EXTERN_C void commobj_FindReverse_35_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	const INT arg2 = pArgInf[2].m_int;
	const BOOL arg3 = pArgInf[3].m_bool;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = self->length() - 1;
	if (!pArgInf[2].empty())
	{
		if (arg2 < 0)
			start = self->length() + arg2;
		if (arg2 > 0)
			start = arg2 - 1;
	}
	int res;
	if (arg3)
		res = self->reversefind(arg1, start);
	else
		res = self->caselessreversefind(arg1, start);
	pRetData->m_int = res < 0 ? res : res + 1;
}

// 调用格式: SDT_BOOL (快速文本对象).替换文本, 命令说明: NULL
// 参数<1>: 起始替换位置 SDT_INT, 参数说明: "位置索引可以为正值，1表示第一个字符，2表示第二个字符，依次类推；位置索引也可以为负值，-1表示最后一个字符，-2表示倒数第二个字符，依次类推。"
// 参数<2>: 替换长度 SDT_INT, 参数说明: NULL
// 参数<3>: [替换为文本 SDT_TEXT], 参数说明: "如果本参数被省略，则删除文本中的指定部分。"
COMMOBJ_EXTERN_C void commobj_ReplaceText_36_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;
	const INT arg2 = pArgInf[2].m_int;
	const LPSTR arg3 = pArgInf[3].m_pText;

	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (arg1 < 0)
		start = self->length() + arg1;
	if (arg1 > 0)
		start = arg1 - 1;
	int len = arg2;
	if (arg2 < 0)
		len = self->length() - start;
	self->replace(start, len, pArgInf[3].empty() ? "" : arg3);
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_INT (快速文本对象).替换子文本, 命令说明: "在本对象文本中查找指定文本，并将其替换为其它文本。返回替换成功次数。"
// 参数<1>: 被替换文本 SDT_TEXT, 参数说明: NULL
// 参数<2>: [替换为文本 SDT_TEXT], 参数说明: "如果本参数被省略，则表示将删除被替换文本。"
// 参数<3>: [起始替换位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字符，2表示第二个字符，依次类推；位置索引也可以为负值，-1表示最后一个字符，-2表示倒数第二个字符，依次类推。如果本参数被省略，默认为1。"
// 参数<4>: [最大替换次数 SDT_INT], 参数说明: "如果为-1，表示不限制替换次数。如果本参数被省略，默认为-1。"
// 参数<5>: 是否区分大小写 SDT_BOOL, 参数说明: NULL
COMMOBJ_EXTERN_C void commobj_ReplaceSubText_37_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	LPSTR arg2 = pArgInf[2].m_pText;
	const INT arg3 = pArgInf[3].m_int;
	INT arg4 = pArgInf[4].m_int;
	const BOOL arg5 = pArgInf[5].m_bool;

	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (pArgInf[2].empty())
		arg2 = static_cast<char*>("");
	if (!pArgInf[3].empty())
	{
		if (arg3 < 0)
			start = self->length() + arg3;
		if (arg3 > 0)
			start = arg3 - 1;
	}
	if (pArgInf[4].empty())
		arg4 = -1;

	auto func = static_cast<int(CBString::*)(const char*, int) const>(&CBString::find);
	if (!arg5)
		func = static_cast<int(CBString::*)(const char*, int) const>(&CBString::caselessfind);

	auto count = 0;
	const int sub_str_len = static_cast<int>(strlen(arg1));
	CBString ret{self->data, start};
	do
	{
		const int pos = (self->*func)(arg1, start);
		if (pos == -1)
			break;
		ret += CBStringView{self->data + start, pos - start};
		ret += arg2;
		start = pos + sub_str_len;
		count++;
	}
	while (arg4 == -1 || count < arg4);
	if (start < self->length())
		ret += CBStringView{self->data + start, self->length() - start};
	*self = ret;
	pRetData->m_int = count;
}

// 调用格式: SDT_TEXT (快速文本对象).[]分割文本, 命令说明: NULL
// 参数<1>: [用作分割的文本 SDT_TEXT], 参数说明: "如果被省略，则默认使用半角逗号“,”字符作为分隔符。如果是一个长度为零的文本，则返回的数组仅包含一个成员，其内容是本对象中的文本。"
// 参数<2>: [要返回的子文本数目 SDT_INT], 参数说明: "如果为-1，表示不限制替换次数。如果本参数被省略，默认为-1。"
COMMOBJ_EXTERN_C void commobj_SplitText_38_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	LPSTR arg1 = pArgInf[1].m_pText;
	INT arg2 = pArgInf[2].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	if (pArgInf[1].empty())
		arg1 = static_cast<LPSTR>(",");
	if (pArgInf[2].empty())
		arg2 = -1;

	auto count = 0;
	util::vector<char*> res{};
	auto start = 0;
	const auto split_len = static_cast<int>(strlen(arg1));
	do
	{
		const int pos = self->find(arg1, start);
		if (pos == -1)
		{
			if (start != self->length())
				res.push(fne::clone_text(reinterpret_cast<char*>(self->data + start), self->length() - start));
			break;
		}
		res.push(fne::clone_text(reinterpret_cast<char*>(self->data + start), pos - start));
		start = pos + split_len;
		count++;
	}
	while (arg2 == -1 || count < arg2);

	pRetData->m_pAryData = fne::copy_array<char*>(res.data(), res.length());
}

// 调用格式: SDT_TEXT (快速文本对象).[]分割长文本, 命令说明: NULL
// 参数<1>: [用作分割的文本 SDT_TEXT], 参数说明: "如果被省略，则默认使用半角逗号“,”字符作为分隔符。如果是一个长度为零的文本，则返回的数组仅包含一个成员，其内容是本对象中的文本。"
// 参数<2>: [要返回的子文本数目 SDT_INT], 参数说明: "如果为-1，表示不限制替换次数。如果本参数被省略，默认为-1。"
COMMOBJ_EXTERN_C void commobj_SplitLongText_39_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	LPSTR arg1 = pArgInf[1].m_pText;
	INT arg2 = pArgInf[2].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	if (pArgInf[1].empty())
		arg1 = static_cast<LPSTR>(",");
	if (pArgInf[2].empty())
		arg2 = -1;

	auto count = 0;
	util::vector<char*> res{};
	auto start = 0;
	const auto split_len = static_cast<int>(strlen(arg1));
	do
	{
		const int pos = self->boyer_moore_find(arg1, start);
		if (pos == -1)
		{
			if (start != self->length())
				res.push(fne::clone_text(reinterpret_cast<char*>(self->data + start), self->length() - start));
			break;
		}
		res.push(fne::clone_text(reinterpret_cast<char*>(self->data + start), pos - start));
		start = pos + split_len;
		count++;
	}
	while (arg2 == -1 || count < arg2);

	pRetData->m_pAryData = fne::copy_array<char*>(res.data(), res.length());
}

// // 调用格式: SDT_TEXT (快速文本对象).[]取出中间文本, 命令说明: NULL
// 参数<1>: 左边文本 SDT_TEXT
// 参数<2>: 右边文本 SDT_TEXT
// 参数<3>: [起始寻找位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字符，2表示第二个字符，依次类推；位置索引也可以为负值，-1表示最后一个字符，-2表示倒数第二个字符，依次类推。如果本参数被省略，默认为1。"
// 参数<4>: [返回的结果数目 SDT_INT], 参数说明: "如果为-1，表示不限制寻找次数。如果本参数被省略，默认为-1。"
// 参数<5>: 是否区分大小写 SDT_BOOL, 参数说明: NULL
COMMOBJ_EXTERN_C void commobj_GetMiddleText_40_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	const LPSTR arg2 = pArgInf[2].m_pText;
	const INT arg3 = pArgInf[3].m_int;
	INT arg4 = pArgInf[4].m_int;
	const BOOL arg5 = pArgInf[5].m_bool;

	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (!pArgInf[3].empty())
	{
		if (arg3 < 0)
			start = self->length() + arg3;
		if (arg3 > 0)
			start = arg3 - 1;
	}

	if (pArgInf[4].empty())
		arg4 = -1;

	auto func = static_cast<int(CBString::*)(const char*, int) const>(&CBString::find);
	if (!arg5)
		func = static_cast<int(CBString::*)(const char*, int) const>(&CBString::caselessfind);
	auto count = 0;
	const auto left_len = static_cast<int>(strlen(arg1));
	const auto right_len = static_cast<int>(strlen(arg2));
	util::vector<char*> res{};
	do
	{
		const int left_pos = (self->*func)(arg1, start);
		if (left_pos == -1)
			break;
		start = left_pos + left_len;
		const int right_pos = (self->*func)(arg2, start);
		if (right_pos == -1)
			break;
		res.push(fne::clone_text(reinterpret_cast<char*>(self->data + start), right_pos - start));
		start = right_pos + right_len;
		count++;
	}
	while (arg4 == -1 || count < arg4);

	pRetData->m_pAryData = fne::copy_array<char*>(res.data(), res.length());
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_41, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__41_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_42, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__42_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_43, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__43_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_44, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__44_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 调用格式: SDT_BOOL (快速文本对象).到大写, 命令说明: "将本对象文本中的全部或部分英文字母变为大写字母。"
// 参数<1>: [起始字符位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字符，2表示第二个字符，依次类推；位置索引也可以为负值，-1表示最后一个字符，-2表示倒数第二个字符，依次类推。如果本参数被省略，默认为1。"
// 参数<2>: [字符个数 SDT_INT], 参数说明: "如果本参数被省略，默认为从参数“起始字符位置”开始到文本结尾的字符个数。"
COMMOBJ_EXTERN_C void commobj_UpperCase_45_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;
	const INT arg2 = pArgInf[2].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (!pArgInf[1].empty())
	{
		if (arg1 < 0)
			start = self->length() + arg1;
		if (arg1 > 0)
			start = arg1 - 1;
	}

	auto len = self->length() - start;

	if (!pArgInf[2].empty())
	{
		len = min(len, arg2);
	}

	for (int i = 0; i < len; ++i)
	{
		self->data[i + start] = static_cast<unsigned char>(toupper(self->data[i + start]));
	}

	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).到小写, 命令说明: "将本对象文本中的全部或部分英文字母变为小写字母。"
// 参数<1>: [起始字符位置 SDT_INT], 参数说明: "位置索引可以为正值，1表示第一个字符，2表示第二个字符，依次类推；位置索引也可以为负值，-1表示最后一个字符，-2表示倒数第二个字符，依次类推。如果本参数被省略，默认为1。"
// 参数<2>: [字符个数 SDT_INT], 参数说明: "如果本参数被省略，默认为从参数“起始字符位置”开始到文本结尾的字符个数。"
COMMOBJ_EXTERN_C void commobj_LowerCase_46_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;
	const INT arg2 = pArgInf[2].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	if (!pArgInf[1].empty())
	{
		if (arg1 < 0)
			start = self->length() + arg1;
		if (arg1 > 0)
			start = arg1 - 1;
	}

	auto len = self->length() - start;

	if (!pArgInf[2].empty())
	{
		len = min(len, arg2);
	}

	for (int i = 0; i < len; ++i)
	{
		self->data[i + start] = static_cast<unsigned char>(tolower(self->data[i + start]));
	}

	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).到全角, 命令说明: "将本对象文本中的所有半角字符变为全角。"
// 无参数
COMMOBJ_EXTERN_C void commobj_QJCase_47_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	const auto len = LCMapString(LANG_SYSTEM_DEFAULT, LCMAP_FULLWIDTH, reinterpret_cast<char*>(self->data),
	                             self->length() + 1, nullptr, 0);
	if (!len)
	{
		pRetData->m_bool = FALSE;
		return;
	}
	auto buffer = static_cast<char*>(malloc(len));

	LCMapString(LANG_SYSTEM_DEFAULT, LCMAP_FULLWIDTH, reinterpret_cast<char*>(self->data), self->length() + 1, buffer,
	            len);

	*self = buffer;
	free(buffer);
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).到半角, 命令说明: "将本对象文本中的所有全角字符变为半角。"
// 无参数
COMMOBJ_EXTERN_C void commobj_QJCase_48_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	const auto len = LCMapString(LANG_SYSTEM_DEFAULT, LCMAP_HALFWIDTH, reinterpret_cast<char*>(self->data),
	                             self->length() + 1, nullptr, 0);
	if (!len)
	{
		pRetData->m_bool = FALSE;
		return;
	}
	auto buffer = static_cast<char*>(malloc(len));

	LCMapString(LANG_SYSTEM_DEFAULT, LCMAP_HALFWIDTH, reinterpret_cast<char*>(self->data), self->length() + 1, buffer,
	            len);

	*self = buffer;
	free(buffer);
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).删首空, 命令说明: "删除本对象文本中首部所有全角或半角空格。"
// 无参数
COMMOBJ_EXTERN_C void commobj_TrimLeft_49_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	self->ltrim();
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).删尾空, 命令说明: "删除本对象文本中尾部所有全角或半角空格。"
// 无参数
COMMOBJ_EXTERN_C void commobj_TrimRight_50_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	self->rtrim();
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).删首尾空, 命令说明: "删除本对象文本中首部和尾部所有全角或半角空格。"
// 无参数
COMMOBJ_EXTERN_C void commobj_Trim_51_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	self->trim();
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).删全部空, 命令说明: "删除本对象文本中所有全角或半角空格（包括首部、尾部及中间）。"
// 无参数
COMMOBJ_EXTERN_C void commobj_TrimAll_52_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	auto& self = fne::args_to_this<CBString>(pArgInf);
	auto start = 0;
	do
	{
		const auto pos = self->findchr(" \t\v\f\r\n", start);
		self->remove(pos, 1);
		start = pos;
	}
	while (start != -1);
	pRetData->m_bool = TRUE;
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_53, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__53_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_54, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__54_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_55, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__55_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_56, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__56_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_57, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__57_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_58, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__58_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_59, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__59_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_60, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__60_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_61, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__61_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_62, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__62_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_63, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__63_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_64, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__64_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_65, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__65_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 调用格式: SDT_BOOL (快速文本对象).从文件读, 命令说明: "从指定的文本文件中读取其所有文本到本对象中。"
// 参数<1>: 文件名 SDT_TEXT, 参数说明: "请提供包含完整路径的文本名称。"
COMMOBJ_EXTERN_C void commobj_ReadFromFile_66_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	const auto file = fopen(arg1, "rb");
	if (!file)
	{
		pRetData->m_bool = FALSE;
		return;
	}
	CBStream stream(reinterpret_cast<bNread>(fread), file);
	stream.read(*self);
	fclose(file);
	pRetData->m_bool = TRUE;
}

// 调用格式: SDT_BOOL (快速文本对象).写到文件, 命令说明: "将本对象中的所有数据写入指定的文件中。如果该文件不存在，则自动创建；如果该文件已经存在，其原有内容将被直接覆盖！"
// 参数<1>: 文件名 SDT_TEXT, 参数说明: "请提供包含完整路径的文本名称。"
COMMOBJ_EXTERN_C void commobj_WriteToFile_67_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const LPSTR arg1 = pArgInf[1].m_pText;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	const auto file = fopen(arg1, "wb");
	if (!file)
	{
		pRetData->m_bool = FALSE;
		return;
	}
	fwrite(self->data, sizeof(char), self->length(), file);
	fclose(file);
	pRetData->m_bool = TRUE;
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_68, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__68_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_69, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__69_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 调用格式: SDT_INT (快速文本对象).取缓冲区, 命令说明: "返回指定大小的缓冲区内存首地址。如果不能获取足够大小的缓冲区，将返回0。可以向该缓冲区直接写入文本数据，但事后必须调用“释放缓冲区()”以调整本对象内部状态。向缓冲区写入数据时请注意不要写到缓冲区之外。"
// 参数<1>: [缓冲区大小 SDT_INT], 参数说明: "应大于零并小于“最大可用内存”。如果本参数被省略，默认为当前文本长度。"
COMMOBJ_EXTERN_C void commobj_GetBuffer_70_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	INT arg1 = pArgInf[1].m_int;
	auto& self = fne::args_to_this<CBString>(pArgInf);
	pRetData->m_int = reinterpret_cast<INT>(self->data);
}

// 调用格式: SDT_BOOL (快速文本对象).释放缓冲区, 命令说明: "本方法只是调整内部状态，并不修改内部文本。另请参考“取缓冲区()”中的说明。"
// 无参数
COMMOBJ_EXTERN_C void commobj_ReleaseBuffer_71_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 调用格式: SDT_BOOL (快速文本对象).置可用内存, 命令说明: "设置本对象内部使用的最小可用内存和最大可用内存。使用本方法可以优化内存使用，但因为内部已经有适当的初始值，普通用户不必调用本方法。"
// 参数<1>: [最小可用内存 SDT_INT], 参数说明: "单位为字节。如果本参数被省略，则保持现有“最小可用内存”数值不变。其内部初始值为10240字节，约10K。"
// 参数<2>: [最大可用内存 SDT_INT], 参数说明: "单位为字节。如果本参数被省略，则保持现有“最大可用内存”数值不变。其内部初始值为2147483647字节，约2G。"
COMMOBJ_EXTERN_C void commobj_SetMemLength_72_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	const INT arg1 = pArgInf[1].m_int;

	auto& self = fne::args_to_this<CBString>(pArgInf);
	self->alloc(arg1);
}

// 调用格式: SDT_BOOL (快速文本对象).置内存增量, 命令说明: "设置本对象内部使用的内存增量值。所谓“内存增量”，即每次需要申请内存时在所需内存的基础上增加的内存数量（多申请出来的内存可供后续操作使用，从而减少了申请内存的次数，提高了执行效率）。正确使用本方法可以优化内存使用并提高执行效率，但因为内部已经有适当的初始值，普通用户不必调用本方法。"
// 参数<1>: 内存增量 SDT_INT, 参数说明: "单位为字节。如果此值过小，可能导致数据操作效率降低；如果此值过大，可能导致消耗较多内存。内部初始值为10240字节，约10K。"
COMMOBJ_EXTERN_C void commobj_SetMemGrowSize_73_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
	INT arg1 = pArgInf[1].m_int;
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_74, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__74_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_75, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__75_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_76, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__76_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_77, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__77_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_78, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__78_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}

// 本命令被隐藏, 原始名字 = "???"
// 调用格式: _SDT_NULL (快速文本对象).无法识别的名字_79, 命令说明: NULL
// 无参数
COMMOBJ_EXTERN_C void commobj__bunengshibie__79_commobj(PMDATA_INF pRetData, INT nArgCount, PMDATA_INF pArgInf)
{
}
